Skip to content

Neutral Atom hybrid compilation extension#1293

Merged
burgholzer merged 26 commits into
mainfrom
na-hybrid-extension
Nov 10, 2025
Merged

Neutral Atom hybrid compilation extension#1293
burgholzer merged 26 commits into
mainfrom
na-hybrid-extension

Conversation

@lsschmid

@lsschmid lsschmid commented Nov 5, 2025

Copy link
Copy Markdown
Collaborator

Description

This PR add functionality needed for an upcoming version of the hybrid mapper in QMAP.
In particular, it adds new types of operations: the "bridge" gate and the "passby" operation (a kind of bridge but with shuttling).

Checklist:

  • The pull request only contains commits that are focused and relevant to this change.
  • I have added appropriate tests that cover the new/changed functionality.
  • The changes follow the project's style guidelines and introduce no new warnings.
  • The changes are fully tested and pass the CI checks.
  • I have reviewed my own code changes.

@coderabbitai

coderabbitai Bot commented Nov 5, 2025

Copy link
Copy Markdown
Contributor
📝 Walkthrough

Walkthrough

Adds a Bridge operation type, a QuantumComputation::bridge(const Targets&) API, OpenQASM emission for "bridge", refactors AodOperation OpenQASM serialization and adds per-dimension helpers, updates op-type enumeration, and adds/adjusts tests for Bridge and AodMove output.

Changes

Cohort / File(s) Summary
Bridge Operation API
include/mqt-core/ir/QuantumComputation.hpp, src/ir/QuantumComputation.cpp
Added public method void bridge(const Targets& targets) which validates targets and appends a StandardOperation of type Bridge. Diff shows the implementation added (possible duplicate definition present).
Operation Type Enumeration
include/mqt-core/ir/operations/OpType.inc
Inserted Handle_OP_TYPE(42, Bridge, 0, "bridge") and updated LAST_OP_TYPE to 43.
OpenQASM Bridge Support
src/ir/operations/StandardOperation.cpp
Extended gate-dumping logic to map the Bridge op type to the "bridge" token for OpenQASM output.
AodOperation Enhancements
src/ir/operations/AodOperation.cpp
Removed <ios> include, refactored dumpOpenQASM() to construct output in a single pass (avoiding seek-based trimming), and added helpers: convertToDimension(...), getStarts(...), getMaxDistance(...), getDistances(...).
Tests
test/ir/test_operation.cpp
Updated AodMove OpenQASM expectations (removed trailing semicolon before closing parenthesis) and added tests asserting Bridge QASM output and non-throwing creation of a 3-qubit bridge.
Changelog
CHANGELOG.md
Added Unreleased entry for bridging gates and appended PR reference.

Sequence Diagram(s)

sequenceDiagram
    actor User
    participant QC as QuantumComputation
    participant Op as StandardOperation
    participant QASM as OpenQASM

    User->>QC: bridge(targets)
    activate QC
    QC->>QC: validate target indices
    QC->>Op: create StandardOperation(type=Bridge, targets)
    QC->>QC: append operation to circuit
    deactivate QC

    Note right of Op `#DDEFEF`: serialization later
    Op->>Op: dumpGateType() -> "bridge"
    Op->>QASM: emit "bridge q[i], q[j], ..."
Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20–30 minutes

  • Check: possible duplicate QuantumComputation::bridge implementation in src/ir/QuantumComputation.cpp.
  • Verify: op-type numeric insertion (index 42) doesn't break assumptions or persisted values.
  • Verify: AodOperation dumpOpenQASM formatting and new helpers for correctness and edge cases.

Poem

🐰 I hop across three qubits with a grin,
A tiny "bridge" begins to spin,
Commas neat and distances found,
OpenQASM sings, circuits bound,
A rabbit cheers — new paths begin.

Pre-merge checks and finishing touches

❌ Failed checks (1 warning, 1 inconclusive)
Check name Status Explanation Resolution
Docstring Coverage ⚠️ Warning Docstring coverage is 0.00% which is insufficient. The required threshold is 80.00%. You can run @coderabbitai generate docstrings to improve docstring coverage.
Title check ❓ Inconclusive The title 'Neutral Atom hybrid compilation extension' is generic and does not clearly convey the main change (adding bridge gate and passby operations). Consider a more specific title like 'Add bridge gate and passby operation for neutral atom hybrid compilation' to better reflect the primary changes.
✅ Passed checks (1 passed)
Check name Status Explanation
Description check ✅ Passed The description covers the main purpose and includes a completed checklist, but omits required template sections like dependencies, documentation updates, and migration instructions.
✨ Finishing touches
  • 📝 Generate docstrings
🧪 Generate unit tests (beta)
  • Create PR with unit tests
  • Post copyable unit tests in a comment
  • Commit unit tests in branch na-hybrid-extension

📜 Recent review details

Configuration used: CodeRabbit UI

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 9428d93 and bbceb09.

📒 Files selected for processing (2)
  • CHANGELOG.md (3 hunks)
  • src/ir/operations/AodOperation.cpp (4 hunks)
🧰 Additional context used
🧬 Code graph analysis (1)
src/ir/operations/AodOperation.cpp (5)
include/mqt-core/ir/operations/AodOperation.hpp (9)
  • dir (77-77)
  • dir (79-79)
  • dir (81-81)
  • dir (83-83)
  • of (85-88)
  • maybe_unused (69-69)
  • maybe_unused (69-69)
  • maybe_unused (71-71)
  • maybe_unused (71-71)
src/ir/operations/StandardOperation.cpp (2)
  • dumpOpenQASM (276-290)
  • dumpOpenQASM (276-279)
src/ir/QuantumComputation.cpp (3)
  • dumpOpenQASM (634-703)
  • dumpOpenQASM (634-634)
  • targets (1584-1584)
src/ir/operations/CompoundOperation.cpp (2)
  • dumpOpenQASM (191-199)
  • dumpOpenQASM (191-195)
src/ir/operations/NonUnitaryOperation.cpp (2)
  • dumpOpenQASM (90-126)
  • dumpOpenQASM (90-94)
🔇 Additional comments (6)
CHANGELOG.md (1)

12-14: LGTM! Changelog entry is well-formatted and correctly positioned.

The entry follows the established format with appropriate emoji (✨), clear description, correct PR reference, and proper author attribution. The PR link is correctly positioned at the top of the PR links section (most recent first), and the contributor reference is added to the contributors list.

Also applies to: 234-234, 359-359

src/ir/operations/AodOperation.cpp (5)

106-114: LGTM: Clean dimension-filtered accessor.

The implementation correctly filters operations by dimension and collects start positions. The logic is straightforward and consistent with the existing getEnds method.


116-122: LGTM: Efficient max distance calculation.

The implementation correctly delegates to getDistances and finds the maximum element. Returning 0 for the empty case is a sensible default.


124-132: LGTM: Correct distance computation.

The implementation correctly filters by dimension and computes absolute distances using std::abs(op.end - op.start).


138-163: LGTM: Refactoring successfully addresses both past reviews.

The implementation now:

  • Writes directly to the output stream without intermediate string buffers (addresses first past review)
  • Uses consistent bool first separator pattern for both operations and qubits (addresses second past review)
  • Produces correct output format: name (op1; op2) qubit0, qubit1, qubit2;\n

The refactoring eliminates unnecessary allocations and maintains clean, readable separator logic.


39-43: No actionable changes needed for toQASMString() despite lack of internal usage.

The verification confirms toQASMString() is not called within the codebase, but it is a public method declared in include/mqt-core/ir/operations/AodOperation.hpp with the [[nodiscard]] attribute. As part of the public API, it should be retained to avoid breaking external code that may depend on it. The refactored dumpOpenQASM() simply opted for a more direct approach to writing operation fields rather than calling this method.


Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

Comment @coderabbitai help to get the list of available commands and usage tips.

@burgholzer burgholzer added enhancement Improvement of existing feature Core Anything related to the Core library and IR c++ Anything related to C++ code NA Anything related to Neutral Atom Quantum Computing labels Nov 5, 2025
@codecov

codecov Bot commented Nov 5, 2025

Copy link
Copy Markdown

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!

@coderabbitai coderabbitai Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actionable comments posted: 1

📜 Review details

Configuration used: CodeRabbit UI

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 869f0b4 and 59efb37.

📒 Files selected for processing (1)
  • src/ir/operations/AodOperation.cpp (4 hunks)
🧰 Additional context used
🧬 Code graph analysis (1)
src/ir/operations/AodOperation.cpp (4)
include/mqt-core/ir/operations/AodOperation.hpp (9)
  • dir (77-77)
  • dir (79-79)
  • dir (81-81)
  • dir (83-83)
  • of (85-88)
  • maybe_unused (69-69)
  • maybe_unused (69-69)
  • maybe_unused (71-71)
  • maybe_unused (71-71)
src/ir/operations/StandardOperation.cpp (2)
  • dumpOpenQASM (276-290)
  • dumpOpenQASM (276-279)
src/ir/QuantumComputation.cpp (2)
  • dumpOpenQASM (634-703)
  • dumpOpenQASM (634-634)
src/ir/operations/CompoundOperation.cpp (2)
  • dumpOpenQASM (191-199)
  • dumpOpenQASM (191-195)
🔇 Additional comments (4)
src/ir/operations/AodOperation.cpp (4)

45-52: LGTM: Helper method implementation is correct.

The convertToDimension helper correctly converts the raw direction vector to the Dimension enum type.


106-132: LGTM: New dimension helper methods are well-implemented.

The three new helper methods (getStarts, getMaxDistance, getDistances) follow a consistent pattern with the existing getEnds method and correctly filter/compute per-dimension values.


153-153: No issues found—project supports C++20.

The codebase is configured to use C++20 across all build targets (via cxx_std_20 in CMakeLists.txt files). Both std::string::ends_with() and std::ranges::max_element are valid C++20 features and will compile correctly.


146-162: No validation issues found—edge cases are handled correctly.

The provided code snippet was incomplete. While lines 146–162 iterate over operations and targets without explicit empty checks, the full implementation (lines 165–167, not shown in the review) properly handles the trailing comma:

if (!content.empty() && content.back() == ',') {
  content.pop_back();
}

Empty collections are gracefully handled: the loops simply don't execute, producing valid output (e.g., name () qubits;). The constructor allows empty qubits and operations vectors—no assertion prevents this—but the code does not crash or produce malformed output in these cases.

Comment thread src/ir/operations/AodOperation.cpp Outdated

@burgholzer burgholzer left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Just had a quick look and this looks pretty solid.
I only have one small comment on the existing changes.

Some more general observations/questions:

Did you purposefully only add this to the C++ parts of the library?
At the very least, I think you need to expose the new OpType enum member to Python (

void registerOptype(const py::module& m) {
py::native_enum<qc::OpType>(m, "OpType", "enum.Enum",
"Enumeration of operation types.")
.value("none", qc::OpType::None)
.value("gphase", qc::OpType::GPhase)
.value("i", qc::OpType::I)
.value("h", qc::OpType::H)
.value("x", qc::OpType::X)
.value("y", qc::OpType::Y)
.value("z", qc::OpType::Z)
.value("s", qc::OpType::S)
.value("sdg", qc::OpType::Sdg)
.value("t", qc::OpType::T)
.value("tdg", qc::OpType::Tdg)
.value("v", qc::OpType::V)
.value("vdg", qc::OpType::Vdg)
.value("u", qc::OpType::U)
.value("u2", qc::OpType::U2)
.value("p", qc::OpType::P)
.value("sx", qc::OpType::SX)
.value("sxdg", qc::OpType::SXdg)
.value("rx", qc::OpType::RX)
.value("ry", qc::OpType::RY)
.value("rz", qc::OpType::RZ)
.value("r", qc::OpType::R)
.value("swap", qc::OpType::SWAP)
.value("iswap", qc::OpType::iSWAP)
.value("iswapdg", qc::OpType::iSWAPdg)
.value("peres", qc::OpType::Peres)
.value("peresdg", qc::OpType::Peresdg)
.value("dcx", qc::OpType::DCX)
.value("ecr", qc::OpType::ECR)
.value("rxx", qc::OpType::RXX)
.value("ryy", qc::OpType::RYY)
.value("rzz", qc::OpType::RZZ)
.value("rzx", qc::OpType::RZX)
.value("xx_minus_yy", qc::OpType::XXminusYY)
.value("xx_plus_yy", qc::OpType::XXplusYY)
.value("compound", qc::OpType::Compound)
.value("measure", qc::OpType::Measure)
.value("reset", qc::OpType::Reset)
.value("barrier", qc::OpType::Barrier)
.value("if_else", qc::OpType::IfElse)
.export_values()
.finalize();
) and add it to the Python Stub File (
class OpType(Enum):
"""Enumeration of operation types."""
barrier = ...
"""
A barrier operation. It is used to separate operations in the circuit.
See Also:
:meth:`mqt.core.ir.QuantumComputation.barrier`
"""
if_else = ...
"""
An if-else operation.
Used to control the execution of an operation based on the value of a classical register.
See Also:
:meth:`mqt.core.ir.QuantumComputation.if_else`
"""
compound = ...
"""
A compound operation. It is used to group multiple operations into a single operation.
See Also:
:class:`.CompoundOperation`
"""
dcx = ...
"""
A DCX gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.dcx`
"""
ecr = ...
"""
An ECR gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.ecr`
"""
gphase = ...
"""
A global phase operation.
See Also:
:meth:`mqt.core.ir.QuantumComputation.gphase`
"""
h = ...
"""
A Hadamard gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.h`
"""
i = ...
"""
An identity operation.
See Also:
:meth:`mqt.core.ir.QuantumComputation.i`
"""
iswap = ...
"""
An iSWAP gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.iswap`
"""
iswapdg = ...
r"""
An :math:`i\text{SWAP}^\dagger` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.iswapdg`
"""
measure = ...
"""
A measurement operation.
See Also:
:meth:`mqt.core.ir.QuantumComputation.measure`
"""
none = ...
"""
A placeholder operation. It is used to represent an operation that is not yet defined.
"""
peres = ...
"""
A Peres gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.peres`
"""
peresdg = ...
r"""
A :math:`\text{Peres}^\dagger` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.peresdg`
"""
p = ...
"""
A phase gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.p`
"""
reset = ...
"""
A reset operation.
See Also:
:meth:`mqt.core.ir.QuantumComputation.reset`
"""
r = ...
r"""
An :math:`R` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.r`
"""
rx = ...
r"""
An :math:`R_x` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.rx`
"""
rxx = ...
r"""
An :math:`R_{xx}` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.rxx`
"""
ry = ...
r"""
An :math:`R_y` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.ry`
"""
ryy = ...
r"""
An :math:`R_{yy}` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.ryy`
"""
rz = ...
r"""
An :math:`R_z` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.rz`
"""
rzx = ...
r"""
An :math:`R_{zx}` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.rzx`
"""
rzz = ...
r"""
An :math:`R_{zz}` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.rzz`
"""
s = ...
"""
An S gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.s`
"""
sdg = ...
r"""
An :math:`S^\dagger` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.sdg`
"""
swap = ...
"""
A SWAP gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.swap`
"""
sx = ...
r"""
A :math:`\sqrt{X}` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.sx`
"""
sxdg = ...
r"""
A :math:`\sqrt{X}^\dagger` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.sxdg`
"""
t = ...
"""
A T gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.t`
"""
tdg = ...
r"""
A :math:`T^\dagger` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.tdg`
"""
u2 = ...
"""
A U2 gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.u2`
"""
u = ...
"""
A U gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.u`
"""
v = ...
"""
A V gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.v`
"""
vdg = ...
r"""
A :math:`V^\dagger` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.vdg`
"""
x = ...
"""
An X gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.x`
"""
xx_minus_yy = ...
r"""
An :math:`R_{XX - YY}` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.xx_minus_yy`
"""
xx_plus_yy = ...
r"""
An :math:`R_{XX + YY}` gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.xx_plus_yy`
"""
y = ...
"""
A Y gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.y`
"""
z = ...
"""
A Z gate.
See Also:
:meth:`mqt.core.ir.QuantumComputation.z`
"""
).
Preferably, one would also expose the new QuantumComputation convenience method (here
qc.def("barrier", py::overload_cast<>(&qc::QuantumComputation::barrier));
qc.def("barrier",
py::overload_cast<qc::Qubit>(&qc::QuantumComputation::barrier), "q"_a);
qc.def("barrier", py::overload_cast<const std::vector<qc::Qubit>&>(
&qc::QuantumComputation::barrier));
and here
@overload
def barrier(self) -> None:
"""Add a barrier to the circuit."""
@overload
def barrier(self, q: int) -> None:
"""Add a barrier to the circuit.
Args:
q: The qubit to add the barrier to
"""
@overload
def barrier(self, qubits: Sequence[int]) -> None:
"""Add a barrier to the circuit.
Args:
qubits: The qubits to add the barrier to
"""
)

Currently, circuits with bridge gates cannot be properly exported to OpenQASM (no definition for the gate is created and/or it is not decomposed into an actual bridge gate sequence of gates; i.e., the resulting QASM file is not valid).
The created QASM files also can't be read into MQT Core because the parser does not know how to handle the new gate.
Similar points hold for the connection from/to Qiskit.
Any circuit containing the newly introduced gate cannot be handled.

I recently introduced a new kind of Standard Gate in #1283.
That PR pretty much outlines the entire spectrum of changes one could wish for when adding a new gate (including changes to the DD and ZX package, which are probably not that necessary here).
I am not saying that we need all of that as part of this PR, but I wanted to make you aware of the limitations of the current scope of the PR.

Comment thread include/mqt-core/ir/operations/OpType.inc Outdated
Co-authored-by: Lukas Burgholzer <burgholzer@me.com>
Signed-off-by: Ludwig Schmid <117631861+lsschmid@users.noreply.github.com>

@coderabbitai coderabbitai Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actionable comments posted: 1

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)
src/ir/operations/AodOperation.cpp (1)

39-43: Need to check for indirect references and whether this is part of a public API:

Remove unused SingleOperation::toQASMString() method (lines 39-43).

The refactored dumpOpenQASM now inlines operation formatting directly, making toQASMString() dead code. Ripgrep found zero call sites—only the definition and declaration. The method can be safely removed from both the implementation and header file.

📜 Review details

Configuration used: CodeRabbit UI

Review profile: ASSERTIVE

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 59efb37 and 9428d93.

📒 Files selected for processing (2)
  • include/mqt-core/ir/operations/OpType.inc (1 hunks)
  • src/ir/operations/AodOperation.cpp (4 hunks)
🧰 Additional context used
🧬 Code graph analysis (1)
src/ir/operations/AodOperation.cpp (5)
include/mqt-core/ir/operations/AodOperation.hpp (5)
  • of (85-88)
  • maybe_unused (69-69)
  • maybe_unused (69-69)
  • maybe_unused (71-71)
  • maybe_unused (71-71)
src/ir/operations/StandardOperation.cpp (2)
  • dumpOpenQASM (276-290)
  • dumpOpenQASM (276-279)
src/ir/QuantumComputation.cpp (3)
  • dumpOpenQASM (634-703)
  • dumpOpenQASM (634-634)
  • targets (1584-1584)
src/ir/operations/CompoundOperation.cpp (2)
  • dumpOpenQASM (191-199)
  • dumpOpenQASM (191-195)
src/ir/operations/NonUnitaryOperation.cpp (2)
  • dumpOpenQASM (90-126)
  • dumpOpenQASM (90-94)
🔇 Additional comments (5)
include/mqt-core/ir/operations/OpType.inc (2)

68-68: LGTM! Binary compatibility preserved as suggested in past review.

The Bridge operation is correctly added at index 42 without shifting any existing operation indices, which preserves binary compatibility with previous releases as discussed in the past review comments.


73-73: LGTM! Correctly updated to reflect the new highest operation index.

The LAST_OP_TYPE value of 43 is correct, as it should be one past the highest operation index (Bridge at 42).

src/ir/operations/AodOperation.cpp (3)

45-52: LGTM!

The conversion helper is straightforward and correctly transforms the input vector element by element.


106-114: LGTM!

The getStarts method correctly filters operations by dimension and collects start values, mirroring the existing getEnds implementation pattern.


116-132: LGTM!

Both helper methods are well-implemented:

  • getDistances correctly computes absolute differences per dimension
  • getMaxDistance properly handles the empty case and uses modern C++20 ranges

Comment thread src/ir/operations/AodOperation.cpp
@lsschmid

Copy link
Copy Markdown
Collaborator Author

Yes, the changes were made intentionally in the C++ part only, similar to the (Aod)Move Operations.

For the current Hybrid Mapper, there is no functionality planned or existing that would require direct Python access. As the Mapper output cannot be valid QASM anyway (due to AOD Movements), I don't really see any benefit and would even argue that it could result in confusion if it exists, but actually it's not intended to be used.
The current use of the "qasm" output is only visual debugging and there es no intent to make it compatible with e.g. Qiskit.

A fully fledged definition of the Bridge gate itself (similar to SWAP) might be valuable also in other cases (although it's no really a popular gate), but is out of scope for this PR I would say.

@burgholzer burgholzer left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Alright, makes sense. Just wanted to make sure that you are aware of the consequences.

The one suggestion by code rabbit seems reasonable. Would be nice if you could quickly apply that diff. Then, this is ready to go.

@burgholzer

Copy link
Copy Markdown
Member

Ah, and I missed one (obvious) thing: Could you please add a changelog entry to the changelog?

@burgholzer burgholzer enabled auto-merge (squash) November 10, 2025 09:49
@burgholzer burgholzer merged commit 24beeda into main Nov 10, 2025
34 checks passed
@burgholzer burgholzer deleted the na-hybrid-extension branch November 10, 2025 13:07
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

c++ Anything related to C++ code Core Anything related to the Core library and IR enhancement Improvement of existing feature NA Anything related to Neutral Atom Quantum Computing

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants